Determining User Preference of Items Based on User Ratings and User Features

ABSTRACT

A set of item-item affinities for a plurality of items is determined based on collaborative-filtering techniques. A set of an item&#39;s nearest neighbor items based on the set of item-item affinities is determined. A set of user feature-item affinities for the plurality of items and a set of user features is determined based on least squared regression. A set of a user feature&#39;s nearest neighbor items is determined based in part on the set of user feature-item affinities. Compatible affinity weights for nearest neighbor items of each item and each user feature are determined and stored. Based on user features of a particular user and items a particular user has consumed, a set of nearest neighbor items comprising nearest neighbor items for user features of the user and items the user has consumed are identified as a set of candidate items, and affinity scores of candidate items are determined. Based at least in part on the affinity scores, a candidate item from the set of candidate items is recommended to the user.

FIELD OF THE INVENTION

The present disclosure relates generally to recommender systems that present users of internet applications with recommendations, and more particularly to a recommender system that presents users of internet applications with recommendations based on the users' tracked behavior and information describing the user.

BACKGROUND OF THE INVENTION

The approaches described in this section are approaches that could be pursued, but are not necessarily approaches that have been previously conceived or pursued. Therefore, unless otherwise indicated, it should not be assumed that any of the approaches described in this section qualify as prior art merely by virtue of their inclusion in this section.

Many current internet applications utilize recommender systems to automate the process of providing recommendations for products and services that might be of interest to the user. Widely deployed on the web, such systems help users explore their interests in many domains such as movies, music, books, websites, electronics, and virtually any other type of information available on the web. The overwhelming volume of movies, music, books, etc. available makes it virtually impossible for a user to familiarize himself with all of the content, making recommendations extremely influential in the process of deciding what to consume. As a result, recommender systems appear everywhere, from independent, community-driven web sites, to large e-commerce powerhouses like Yahoo.com®. Recommender systems can improve a user's experience by personalizing what the user sees, often leading to greater engagement and loyalty. Merchants, in turn, receive more explicit preference information that paints a clearer picture of customers.

Two different designs for recommender systems are commonly adopted: content-based filtering systems and collaborative filtering systems. Content-based filtering systems use behavioral data about a user and item content information to recommend items similar to those consumed or rated by the user in the past. Items are represented as a set of item features. For example, a movie might be represented as a set of item features such as genre, actors, directors, box office, release date, average critic review ratings, average user ratings, and so on. Content-based filtering systems can generate user profiles based on the content descriptions of the items previously consumed by the user. For example, if most of the movies the user has watched are action movies starring a particular actor, then the system might heavily weight those two item features and recommend to the user other action movies with that same actor. Instead of generating a profile based on all movies the user has consumed, the profile might be based only on movies the user has positively rated, indicating that the user enjoyed those particular movies.

The system can recommend new movies to users if item features of new movies match well to the profile of the user. The system, however, does not work well, or in some cases not work at all, for new users who do not have profiles. For new users, the system may ask the user to answer a questionnaire, which may seek a variety of information such as demographic information and answers to questions such as “what kinds of genre do you like?” or “who are your favorite actors?” Based on the information from the questionnaire, the system can generate an initial profile for the user and update that profile as the user consumes new items. This method, however, often increases the burden on users which hurts user experiences and can result in a loss of users. Additionally, content-based filtering systems generally only recommend items that are similar to items previously consumed by the user. For example, if a user has watched only romance movies, then a content-based filtering system might only recommend romance movies, which can often cause low satisfaction of recommendations due to a lack of diversity for new or casual users who have not revealed many of their interests. Another limitation of content-based filtering is that its performance highly depends on the quality of item feature generation and selection.

Collaborative filtering systems typically work by associating a user with a group of like-minded users, and then recommending items enjoyed by others in the group. A significant difference between content-based filtering and collaborative filtering is that content-based filtering typically only uses a single user's information while collaborative filtering can use community information such as ratings from a group of other users who have similar tastes. Collaborative filtering has several benefits over content-based filtering. First, collaborative filtering does not require any item feature generation and selection methods and can be applied to any domains where user ratings (either explicit or implicit) are available, thus making collaborative filtering content-independent. Second, collaborative filtering can provide “serendipitous finding,” whereas content-based filtering cannot. For example, even though a user has watched only romance movies, a comedy movie might be recommended to the user if most other romance movie fans also enjoyed that comedy. Collaborative filtering can capture this kind of hidden connection between items by analyzing user consumption history (or user ratings of items) over the population of users.

While content-based filtering can use a profile of an individual user, content-based filtering does not exploit profiles of other like-minded users. Although collaborative filtering often performs better than content-based filtering when a lot of user ratings are available, collaborative filtering suffers from cold-start problems where only a small amount of information is available for users or items. For example, collaborative filtering cannot make recommendations to new users due to the lack of information on new users and cannot recommend new items if no users have yet rated those new items. Also, the quality of recommendations for casual users who have consumed only a few items is typically poor because the system is making recommendations based on limited data.

A key challenge in any recommender systems, including content-based and collaborative filtering systems, is how to provide recommendations at early stages when available data is sparse. The problem is most severe when a new system launches and most users and items are new, but the problem never goes away completely as new users and items are added to the system. Therefore, there exists in the art a need for a recommender system that overcomes the disadvantages of standard content-based filtering system and standard collaborative-based filtering systems.

BRIEF DESCRIPTION OF THE DRAWINGS

The present invention is illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings.

FIGS. 1 a and 1 b are flow charts illustrating methods embodying aspects of the present invention.

FIG. 2 is an example of a user-item matrix.

FIG. 3 is an example of a matrix storing item-item affinity values.

FIG. 4 is an example of a matrix storing feature-item affinity values.

FIG. 5 is a block diagram that illustrates a computer system upon which an embodiment of the invention may be implemented.

DETAILED DESCRIPTION OF EMBODIMENTS OF THE INVENTION

In the following description, for the purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It will be apparent, however, that the present invention may be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form in order to avoid unnecessarily obscuring the present invention.

General Overview

Techniques described herein involve using a hybrid recommender system, which combines standard least squared linear regression and collaborative filtering techniques, to overcome the shortcomings of the prior art. Hybrid methods can be especially useful when data is sparse, for example in cold-start situations. In fact, in the extreme cold-start setting, pure collaborative filtering methods cannot provide recommendations at all, and content-based information filtering methods or hybrid methods are needed.

Embodiments of the present invention include a hybrid recommender system for providing recommendations. FIG. 1 a is a flow chart illustrating a method that could be performed by a recommender system embodying aspects of the present invention. The method comprises determining a set of item-item affinities for a plurality of items (block 110 a), wherein the item-item affinity for two items is a value corresponding to the similarity between the groups of people who like or dislike the first item and the groups of people who like or dislike the second item. The method further comprises, determining a first set of nearest neighbor items for each item or a subset of items based in part on the set of item-item affinities (block 120 a), wherein the set of an item's nearest neighbors corresponds to a subset of the plurality of items that has the strongest affinity to the item. The method further comprises determining a set of user feature-item affinities between some or all of the plurality of items and a set of user features (block 130 a), wherein the user feature-item affinity corresponds to the correlation between a user feature and how strongly users with that user feature in their profile like or dislike a particular item. The method further comprises determining a set of nearest neighbor items for each user feature based in part on the set of user feature-item affinities (block 140 a), wherein the set of the user feature's nearest neighbors corresponds to a set of items that have the strongest affinity towards the user feature. The method further comprises storing the set of nearest neighbor items for each item and user feature in a common data structure such as a matrix and determining compatible affinity weights for both item-item affinity and user feature-item affinity (block 150 a).

FIG. 1 b is a flow chart illustrating a method that could be performed by a recommender system embodying aspects of the present invention. The method comprises receiving a request for an item from a user (block 110 b) and extracting information about the user, such as user features in the user's profile and items that the user has previously requested (block 120 b). The method further comprises determining a set of candidate items comprised of nearest neighbor items for each item and each user feature extracted from the user's profile (block 130 b) and computing an affinity score for each item in the set of candidate items (block 140 b). The extraction of nearest neighbor items to determine the set of candidate items can, for example, be based on information stored in the common data structure described in block 150 a of FIG. 1 a. From the set of candidate items, a subset of items can be selected and presented to the user as recommendations (block 150 b).

Although the blocks in FIG. 1 a and FIG. 1 b have been presented in a particular order for purposes of explanation, it will be appreciated by one of ordinary skill in the art that the steps corresponding to the various blocks can be performed in a different order or performed simultaneously depending on implementation preferences. For example, the steps described in blocks 110 a and 120 a may be performed after or in parallel with the steps described in blocks 130 a and 140 a. Additionally, various aspects of the present invention can be performed either offline or in real time depending on implementation preferences. For example, various aspects of the present invention described in FIG. 1 a might be performed periodically offline while aspects of FIG. 1 b might be performed in real time in response to a user request.

Item-Item Affinity Computation and Finding the Top K Nearest Neighbor Items of Each Item

Techniques described herein involve determining an item-item affinity for a plurality of items. Item-item affinity generally results from the similarity between the groups of users to which any two items appeal and do not appeal. For example, if the group of people who like item A substantially overlaps with the group of people who like item B, and if the group of people who dislike item A substantially overlaps with the group of people who dislike item B, then items A and B are considered to have a high or strong affinity. Conversely, if the group of people who like item A only minimally overlaps with the group of people who like item B, then items A and B can be considered to have a low or weak affinity.

FIG. 2 shows an n-by-m user-item rating matrix (abbreviated R) where n and m denote the number of users and items. The matrix can be generated by storing user information based on information such as user-entered data or tracked behavior data. Examples of such information include whether a user added or deleted a particular item from a list, whether a user clicked or viewed a particular item, or what rating a user gave a particular item. Depending on the type of user information contained in the matrix, each entry in the matrix can be either binary or non-binary. For example, if the matrix is tracking whether or not a user clicked on a particular item, then the entry might be binary, with R_(ui) equaling 1 if a user u has clicked on item i but R_(ui) equaling 0 if user u has not clicked on item i. FIG. 2 shows an example of a binary matrix, but if a matrix is tracking a user's movie reviews, for example, then the entries in the matrix might be numbers between 0 and 1, 1 and 5, or 0 and 100 or any other non-binary values.

As new information about items is obtained, the user-item rating matrix, as well as the other data structures discussed in this disclosure, can be updated accordingly. Techniques employed in certain embodiments of the present invention can include either updating the user-item rating matrix in real time or not updating the user-item rating matrix in real time. For systems managing a large number of users and a large number of items, system performance might be enhanced by periodically updating the user-item rating matrix as opposed to updating the user-item rating matrix in real time.

The term “item” as used herein refers generically to any product or service, either tangible or intangible, which could be consumed by a user. For example, an item might be a module within a customizable web page, and a system embodying aspects of the present invention might be configured to recommend modules such as a sports news module, a financial news module, or a movie module to users. The term “item” can also refer to tangible products such as DVDs, clothing, or consumer electronics, or to services such as travel or financial advice. One of ordinary skill in the art will appreciate that what the term “item” can refer to in the context of this disclosure is virtually limitless.

Each user in the user-item rating matrix can be normalized such that Σ_(iεM)r′_(ui) ²=1. Thus r′_(ui)=r_(ui)/√{square root over (Σ_(jεM)r_(uj′) ²)}. The normalization can minimize the affects of users who rate lots of items because such users are typically not good indicators of user preferences. Thus, it is beneficial to reduce the effect of those users' ratings when similarity of items is calculated.

Item similarity can also be normalized such that r″_(ui)=r′_(ui)/√{square root over (Σ_(vεV)r′_(ui) ²)}. In the above equations, M represents a set of all items, and U represents a set of all users. Each column is thus a unit-length vector, making computation of cosine similarity simpler. One of ordinary skill in the art will appreciate that alternative normalization techniques such as r″_(ui)=r_(ui)− r_(u) − r_(i) + r, where r_(u) is the average rating of the user u (or the fraction of items the user u has rated) and r_(i) is the average rating of the item i (or the fraction of users who has rated the item i). Under such an approach, r denotes the average rating (or density ratio such that what fraction of entry is filled in), and r_(ui) denotes the normalized rating r″_(ui) hereafter.

As each column of matrix R is a unit-length vector, the cosine similarity between an item i and item j can be defined as cos(i,j)=Σ_(uεV)r_(ui)·r_(uj), item i represents an item a user has consumed and item j represents a candidate item that might be recommended to the user. In some instances, the cosine similarity might be defined by few common users. For example, item i and j might have only been rated by two users each and only one common user who rated both items. In such an instance, the cosine similarity of item i and j will be 0.5. A technique of the present invention includes “penalizing” or lessening the importance given to a cosine similarity based on only a few common users. Common means of penalizing include determining:

${\cos \left( {i,j} \right)}^{\prime} = {{\frac{\min \left( {\gamma,c_{ij}} \right)}{\gamma}{\cos \left( {i,j} \right)}\mspace{14mu} {or}\mspace{14mu} {\cos \left( {i,j} \right)}^{\prime}} = {\frac{c_{ij}}{c_{ij} + \gamma}{\cos \left( {i,j} \right)}}}$

where c_(ij) and γ are the number of common users rating both items and a shrinkage parameter. Note that if c_(ij)>>γ, cos(i,j)′≅cos(i,j) and if c_(ij)<<γ, cos(i,j)′≅0. γ can be determined based on cross validation testing to determine a value that provides the highest performance based on system implementation preferences, for example γ=50.

Then for each item, the top K nearest neighbor items based on the cosine similarity can be determined. The list of nearest neighbor items of an item is a list of candidate items that have the strongest affinity towards the item. The value of K can be selected by a system designer based on implementation preferences, for example by cross-validation testing to determine a value of K that provides the best performance in offline tests. For example, K might equal 100.

FIG. 3 shows an example of a matrix storing values for item-item affinities determined based on cosine similarities as described above. The item-item affinity for item 1 and item 4, for example, is 0.3. Each item does not have an affinity towards itself, as illustrated in FIG. 3 by the X at the squares corresponding to item 1-item 1, item 2-item 2, etc. For simplicity of explanation, the majority of boxes in FIG. 3 have been left blank, but in an actual system those matrix entries would likely contain a value. From the matrix, the top K nearest neighbors for an item can be determined. For example, for item 1 the top 3 nearest neighbors would be item 3, item 7, and item 9 because those items have the strongest affinity as indicated by the values in those matrix entries.

User Feature-Item Affinity Computation and Finding the Top K Nearest Neighbor Items of Each User Feature

Techniques employed in certain embodiments of the present invention further include determining a user feature-item affinity for a plurality of items and a plurality of user features. User feature refer to features, such as age, gender, and geographic location, that can be used to describe a user, and user feature-item affinity generally describes the correlation between a user feature shared by a group of users and whether those users like or dislike an item. For example, if item A is disproportionately liked by female users but disproportionately disliked by male users, then item A has a stronger user feature-item affinity towards women than to men. Or alternatively, if 35% of users over the age of 55 like item A, but only 3% of users between the ages of 18 and 25 like item A, then item A has a stronger affinity towards users over the age of 55 than to users between the ages of 18 and 25.

Techniques of the present invention further include maintaining a n-by-m user-item matrix (Y), a n-by-f user profile matrix (F), and a f-by-m weight matrix (W), such that Y≈FW. Matrix W stores the values corresponding to the user feature-item affinity. Y can be the same matrix as R or it can be a matrix storing alternative information. For example, Y might be generated by using module addition and deletion data. For example, Y_(uj) might equal 1 if a user u has added a module j and that module has not been deleted. Y_(uj) might equal −1 if the user u has deleted the module j, and Y_(uj) might be empty or equal to zero if the user u has neither added nor deleted module j.

A user profile matrix (F) can contain information relating to several types of user features such as age, gender, location and BT (Behavioral Targeting) information. An example of BT information might include monitoring activity within a network, such as identifying the frequency with which a user consumes a certain item compared to other users (e.g., identifying a user as in the top 30% of Yahoo! users for frequency of reading “Yahoo! Sports”). The features of users can be selected by “support,” where the “support” of a user feature means the number of users having that user feature in their profile. Depending on implementation preference, only user features of high support above a predetermined threshold such as 5% of the population might be selected. Each user feature can have a binary value. For example, age information might be based on ten age groups, meaning ten age-group user features exist and at most one of the ten age-group user features for each user will have a non-zero value. Gender information might have two user features, where male is represented as 10 and female is represented as 01. Unknown gender can be represented as 00. Geographic information might have 51 location user features if the information is based on associating a user with one of the 50 states or the District of Columbia, or might have 1000 location user features if the geographic information is based on which of the 1000 largest cities in the country a user is closest to. BT information can refer to any monitorable behavioral information that a system designer wishes to monitor, and can be either binary or non-binary, depending on the type of information. Thus, if for example, a system monitors 15 age groups, 2 genders, 1000 locations, and 200 types of BT information, then the system, in total, monitors 1217 possible user features. Each row of F can be normalized such that Σ_(b)f_(ub) ²=1 and Σ_(V)f_(ub′) ²=1, where b denotes BT user features and b′ denotes non-BT user features such as locations, age, and gender.

Since Y and F are known, values for W can be determined by using Least Square Regression (LSR) such as by minimizing ∥Y−FW∥+c∥W∥ where c is an arbitrary constant decided by cross-validation testing. FIG. 4 shows an example of matrix W, which stores values of user feature-item affinity based on the LSR calculation described above. After determining W, for each user feature, the top K nearest neighbor items based on W_(fj) in the W matrix can be determined. Items with negative weight can be ignored.

Merging Item-Item Affinity and User Feature-Item Affinity

Techniques employed in certain embodiments of the present invention further include merging item-item affinity and user feature-item affinity to generate a recommendation to a user based on the top K nearest neighbors for each item the user has consumed and each user feature of the user, wherein the top K nearest neighbors for each item and user feature have corresponding weights. Assume, for example, that there is a user who clicked the item i and possesses user feature f. K_(i) represents a set of the top K nearest neighbor items of the item i based on cosine similarity. K_(f) represents a set of the top K nearest neighbors items of the user feature f based on LSR. In an example where K is equal to 100 for both item-item affinity and user feature-item affinity, Ki will consist of 100 nearest neighbor items and Kf will consist of 100 nearest neighbor items. There may be overlap between Ki and Kf such that the total number of unique items in Ki and Kf is less than 200, or there may be no overlap such that Ki and Kf will consist of 200 unique items.

Since weights of item-item (sim(i,j)) and user feature-item (w_(fj)) affinity are not comparable, it can be difficult to combine them to generate a recommendation. Thus, a technique employed in one embodiment of the present invention includes recalculating weights of neighbors based on the lift such as

$l_{sj} = {\log_{e}\frac{{pr}\left( {js} \right)}{{pr}(j)}}$

where sεI_(u)∪F_(u). I_(u) denotes a set of items that the user u has rated. F_(u) is a set of user features that the user u possesses. Thus, s can be either one of the user features the user possesses of or one of the items the user has rated. Additionally, pr(j) is a fraction of users who have rated the item j, and pr(j|s) is a conditional probability such as the fraction of the users having the user feature s who have also rated the item j.

It may be noted that

$\frac{{pr}\left( {js} \right)}{{pr}(j)}$

is the same as

$\frac{{N\left( {s\bigcap j} \right)} \cdot N}{{N(s)} \cdot {N(j)}}$

where N, N(j), and N(s∩j) denote the number of the total users, the number of the users who have rated an item j, and the number of the users who have user feature s and have rated the item j. Thus l_(sj) can be rewritten as follows:

$l_{sj}\left\{ \begin{matrix} {\log_{e}\frac{N\left( {s\bigcap j} \right)}{{N(s)} \cdot {N(j)}}} & {{{{{{if}\mspace{14mu} j} \in K_{s}}\&}\mspace{14mu} {N\left( {s\bigcap j} \right)}} \geq 10} \\ 0 & {otherwise} \end{matrix} \right.$

If N(s∩j) is less than a value, such as 10, then candidate j might be ignored because the lift is based on too few common users, and confidence on that candidate is too low.

This kind of filtering has the additional benefit of removing noise caused by too little data from the recommendation. Additionally or alternatively, the same “penalty concept” discussed above may also be used to lower affinity weights for low confidence candidates.

If

$\frac{{pr}\left( {js} \right)}{{pr}(j)}$

is a value greater than 1, then pr(j|s) is greater than pr(j), meaning that the percentage of users who share a user feature and rate item j is greater than the global popularity of j, and thus the value of l_(sj) is positive, indicating candidate j might be a candidate to be recommended to a user. If

$\frac{{pr}\left( {js} \right)}{{pr}(j)}$

is a value less than 1, then pr(j|s) is less than pr(j), meaning that the percentage of users who share a user feature and rate item j is less than the global popularity of j, and thus the value of l_(sj) is negative, indicating candidate j might not be a candidate to be recommended to a user. Typically, a high value for l_(sj) indicates a stronger probability that a user with user feature s will like candidate j. Recomputed affinity weights of nearest neighbors of each item and each user feature can be stored in a database.

Scoring Items and Generating Recommendation for a User

A system embodying techniques of the present invention can include a recommender system configured to retrieve from a user profile user features of the user and user behavior history describing what items the user has consumed or rated. The nearest neighbor items of each user feature and each item (l_(si)) can be extracted from the database as candidate items. Affinity scores of each candidate item can be determined as the summation of affinity weights between the candidate item and each user feature of the user and/or each item the user has consumed. For example, the affinity score of an item j for a user u can be defined as

$P_{uj} = {\sum\limits_{S \in {I_{u}\bigcup F_{u}}}{l_{sj}.}}$

The item or items that have the highest affinity score can then be recommended to the user.

Hardware Overview

According to one embodiment, the techniques described herein are implemented by one or more special-purpose computing devices. The special-purpose computing devices may be hard-wired to perform the techniques, or may include digital electronic devices such as one or more application-specific integrated circuits (ASICs) or field programmable gate arrays (FPGAs) that are persistently programmed to perform the techniques, or may include one or more general purpose hardware processors programmed to perform the techniques pursuant to program instructions in firmware, memory, other storage, or a combination. Such special-purpose computing devices may also combine custom hard-wired logic, ASICs, or FPGAs with custom programming to accomplish the techniques. The special-purpose computing devices may be desktop computer systems, portable computer systems, handheld devices, networking devices or any other device that incorporates hard-wired and/or program logic to implement the techniques.

For example, FIG. 5 is a block diagram that illustrates a computer system 500 upon which an embodiment of the invention may be implemented. Computer system 500 includes a bus 502 or other communication mechanism for communicating information, and a hardware processor 504 coupled with bus 502 for processing information. Hardware processor 504 may be, for example, a general purpose microprocessor.

Computer system 500 also includes a main memory 506, such as a random access memory (RAM) or other dynamic storage device, coupled to bus 502 for storing information and instructions to be executed by processor 504. Main memory 506 also may be used for storing temporary variables or other intermediate information during execution of instructions to be executed by processor 504. Such instructions, when stored in storage media accessible to processor 504, render computer system 500 into a special-purpose machine that is customized to perform the operations specified in the instructions.

Computer system 500 further includes a read only memory (ROM) 508 or other static storage device coupled to bus 502 for storing static information and instructions for processor 504. A storage device 510, such as a magnetic disk or optical disk, is provided and coupled to bus 502 for storing information and instructions.

Computer system 500 may be coupled via bus 502 to a display 512, such as a cathode ray tube (CRT), for displaying information to a computer user. An input device 514, including alphanumeric and other keys, is coupled to bus 502 for communicating information and command selections to processor 504. Another type of user input device is cursor control 516, such as a mouse, a trackball, or cursor direction keys for communicating direction information and command selections to processor 504 and for controlling cursor movement on display 512. This input device typically has two degrees of freedom in two axes, a first axis (e.g., x) and a second axis (e.g., y), that allows the device to specify positions in a plane.

Computer system 500 may implement the techniques described herein using customized hard-wired logic, one or more ASICs or FPGAs, firmware and/or program logic which in combination with the computer system causes or programs computer system 500 to be a special-purpose machine. According to one embodiment, the techniques herein are performed by computer system 500 in response to processor 504 executing one or more sequences of one or more instructions contained in main memory 506. Such instructions may be read into main memory 506 from another storage medium, such as storage device 510. Execution of the sequences of instructions contained in main memory 506 causes processor 504 to perform the process steps described herein. In alternative embodiments, hard-wired circuitry may be used in place of or in combination with software instructions.

The term “storage media” as used herein refers to any media that store data and/or instructions that cause a machine to operation in a specific fashion. Such storage media may comprise non-volatile media and/or volatile media. Non-volatile media includes, for example, optical or magnetic disks, such as storage device 510. Volatile media includes dynamic memory, such as main memory 506. Common forms of storage media include, for example, a floppy disk, a flexible disk, hard disk, solid state drive, magnetic tape, or any other magnetic data storage medium, a CD-ROM, any other optical data storage medium, any physical medium with patterns of holes, a RAM, a PROM, and EPROM, a FLASH-EPROM, NVRAM, any other memory chip or cartridge.

Storage media is distinct from but may be used in conjunction with transmission media. Transmission media participates in transferring information between storage media. For example, transmission media includes coaxial cables, copper wire and fiber optics, including the wires that comprise bus 502. Transmission media can also take the form of acoustic or light waves, such as those generated during radio-wave and infra-red data communications.

Various forms of media may be involved in carrying one or more sequences of one or more instructions to processor 504 for execution. For example, the instructions may initially be carried on a magnetic disk or solid state drive of a remote computer. The remote computer can load the instructions into its dynamic memory and send the instructions over a telephone line using a modem. A modem local to computer system 500 can receive the data on the telephone line and use an infra-red transmitter to convert the data to an infra-red signal. An infra-red detector can receive the data carried in the infra-red signal and appropriate circuitry can place the data on bus 502. Bus 502 carries the data to main memory 506, from which processor 504 retrieves and executes the instructions. The instructions received by main memory 506 may optionally be stored on storage device 510 either before or after execution by processor 504.

Computer system 500 also includes a communication interface 518 coupled to bus 502. Communication interface 518 provides a two-way data communication coupling to a network link 520 that is connected to a local network 522. For example, communication interface 518 may be an integrated services digital network (ISDN) card, cable modem, satellite modem, or a modem to provide a data communication connection to a corresponding type of telephone line. As another example, communication interface 518 may be a local area network (LAN) card to provide a data communication connection to a compatible LAN. Wireless links may also be implemented. In any such implementation, communication interface 518 sends and receives electrical, electromagnetic or optical signals that carry digital data streams representing various types of information.

Network link 520 typically provides data communication through one or more networks to other data devices. For example, network link 520 may provide a connection through local network 522 to a host computer 524 or to data equipment operated by an Internet Service Provider (ISP) 526. ISP 526 in turn provides data communication services through the world wide packet data communication network now commonly referred to as the “Internet” 528. Local network 522 and Internet 528 both use electrical, electromagnetic or optical signals that carry digital data streams. The signals through the various networks and the signals on network link 520 and through communication interface 518, which carry the digital data to and from computer system 500, are example forms of transmission media.

Computer system 500 can send messages and receive data, including program code, through the network(s), network link 520 and communication interface 518. In the Internet example, a server 530 might transmit a requested code for an application program through Internet 528, ISP 526, local network 522 and communication interface 518.

The received code may be executed by processor 504 as it is received, and/or stored in storage device 510, or other non-volatile storage for later execution.

Extensions and Alternatives

In this description certain process steps are set forth in a particular order, and alphabetic and alphanumeric labels may be used to identify certain steps. Unless specifically stated in the description, embodiments of the invention are not necessarily limited to any particular order of carrying out such steps. In particular, the labels are used merely for convenient identification of steps, and are not intended to specify or require a particular order of carrying out such steps.

In the foregoing specification, embodiments of the invention have been described with reference to numerous specific details that may vary from implementation to implementation. Thus, the sole and exclusive indicator of what is the invention, and is intended by the applicants to be the invention, is the set of claims that issue from this application, in the specific form in which such claims issue, including any subsequent correction. Any definitions expressly set forth herein for terms contained in such claims shall govern the meaning of such terms as used in the claims. Hence, no limitation, element, property, feature, advantage or attribute that is not expressly recited in a claim should limit the scope of such claim in any way. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense. 

1. A method comprising: determining a set of item-item affinities between a first item and a first plurality of items; determining a first set of nearest neighbor items from the first plurality of items based in part on the set of item-item affinities; determining a set of user feature-item affinities between a second plurality of items and a set of user features; determining a second set of nearest neighbor items based at least in part on the set of user feature-item affinities; determining affinity weights for a set of candidate items, the set of candidate items to be determined at least in part on the first set of nearest neighbor items and the second set of nearest neighbor items; presenting to a user as a recommendation a candidate item from the set of candidate items, the candidate item to be determined at least in part based on an affinity weight of the candidate item; and, wherein the method is performed by one or more computing devices programmed to be special purpose machines pursuant to program instructions.
 2. The method of claim 1, wherein the set of item-item affinities are determined by a cosine similarity function.
 3. The method of claim 1, wherein the set of user feature-item affinities is determined by a least squares regression function.
 4. The method of claim 1, wherein the set of item-item affinities is determined at least based in part on user ratings of the first plurality of items.
 5. The method of claim 4 further comprising: penalizing an item-item affinity within the set of item-item affinities if the item-item affinity is based on fewer than a minimum number of user ratings.
 6. The method of claim 1, wherein at least one user feature from the set of user features is selected from the group consisting of user age, user gender, and geographic location.
 7. The method of claim 1, wherein at least one user feature from the set of user features comprises behavioral targeting information.
 8. The method of claim 1, further comprising: recalculating a weighting of the first set of nearest neighbors items or the second set of nearest neighbor items.
 9. The method of claim 1, wherein the affinity weight of the candidate item is based at least in part on a number of total users, a number of users who have rated the candidate item (N_((j))), a number of users who have an attribute (N_((s))), and a number of users who have the attribute and have also rated the candidate item (N_((s,j))), wherein N_((s)) is one of a number of users who have a particular user feature or a number of users who have rated another item.
 10. The method of claim 9, further comprising: ignoring a second candidate item from the set of candidate items in response to N_((s,j)) being below a value.
 11. One or more machine-readable storage media storing instructions which, when executed by one or more hardware processors, cause performance of the method recited in claim
 1. 12. One or more machine-readable storage media storing instructions which, when executed by one or more hardware processors, cause performance of the method recited in claim
 2. 13. One or more machine-readable storage media storing instructions which, when executed by one or more hardware processors, cause performance of the method recited in claim
 3. 14. One or more machine-readable storage media storing instructions which, when executed by one or more hardware processors, cause performance of the method recited in claim
 4. 15. One or more machine-readable storage media storing instructions which, when executed by one or more hardware processors, cause performance of the method recited in claim
 5. 16. One or more machine-readable storage media storing instructions which, when executed by one or more hardware processors, cause performance of the method recited in claim
 6. 17. One or more machine-readable storage media storing instructions which, when executed by one or more hardware processors, cause performance of the method recited in claim
 7. 18. One or more machine-readable storage media storing instructions which, when executed by one or more hardware processors, cause performance of the method recited in claim
 8. 19. One or more machine-readable storage media storing instructions which, when executed by one or more hardware processors, cause performance of the method recited in claim
 9. 20. One or more machine-readable storage media storing instructions which, when executed by one or more hardware processors, cause performance of the method recited in claim
 10. 